package com.photo.photePro.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.photo.photePro.common.R;
import com.photo.photePro.entity.User;
import com.photo.photePro.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.DigestUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDateTime;

/**
 * 用户Controller
 */
@Slf4j
@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 用户登录
     */
    @PostMapping("/login")
    public R<User> login(@RequestBody User user) {
        log.info("用户登录请求：username = {}, type = {}", user.getUsername(), user.getType());
        
        // 1. 根据用户名查询用户
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        if (user.getType() == 1) {
            // 管理员登录，使用用户名查询
            queryWrapper.eq(User::getUsername, user.getUsername());
        } else {
            // 参赛者登录，使用手机号查询
            queryWrapper.eq(User::getPhone, user.getUsername());
        }
        User u = userService.getOne(queryWrapper);
        
        // 2. 判断用户是否存在
        if (u == null) {
            return R.error("用户名不存在");
        }
        
        // 3. 密码比对
        // 对页面提交的密码进行md5加密处理
        String password = DigestUtils.md5DigestAsHex(user.getPassword().getBytes());
        if (!u.getPassword().equals(password)) {
            return R.error("密码错误");
        }
        
        // 4. 判断用户状态
        if (u.getStatus() == 0) {
            return R.error("用户已被禁用");
        }
        
        // 5. 根据type检查用户角色
        Integer type = user.getType();
        if (type != null) {
            log.info("检查用户角色：用户ID = {}, 用户名 = {}, 角色 = {}, 请求类型 = {}", 
                    u.getId(), u.getUsername(), u.getRole(), type);
                    
            if (type == 1 && u.getRole() != 2) {
                log.warn("用户尝试管理员登录但角色不匹配：用户ID = {}, 角色 = {}", u.getId(), u.getRole());
                return R.error("您不是管理员，无法登录");
            }
            if (type == 3 && u.getRole() != 3) {
                log.warn("用户尝试参赛者登录但角色不匹配：用户ID = {}, 角色 = {}", u.getId(), u.getRole());
                return R.error("您不是参赛者，无法登录");
            }
        }
        
        // 6. 登录成功，去除密码后返回用户信息
        log.info("用户登录成功：用户ID = {}, 角色 = {}", u.getId(), u.getRole());
        u.setPassword(null);
        return R.success(u);
    }

    /**
     * 用户注册
     */
    @PostMapping("/register")
    public R<String> register(@RequestBody User user) {
        // 1. 判断用户名是否已存在
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(User::getUsername, user.getUsername());
        User exist = userService.getOne(queryWrapper);
        
        if (exist != null) {
            return R.error("用户名已存在");
        }
        
        // 2. 密码加密
        String password = DigestUtils.md5DigestAsHex(user.getPassword().getBytes());
        user.setPassword(password);
        
        // 3. 设置默认属性
        user.setStatus(1); // 正常状态
        user.setRole(1); // 普通用户
        user.setCreateTime(LocalDateTime.now());
        user.setUpdateTime(LocalDateTime.now());
        
        // 4. 保存用户
        userService.save(user);
        
        return R.success("注册成功");
    }

    /**
     * 获取用户信息
     */
    @GetMapping("/{id}")
    public R<User> getById(@PathVariable Long id) {
        User user = userService.getById(id);
        if (user != null) {
            user.setPassword(null); // 去除密码
            return R.success(user);
        }
        return R.error("用户不存在");
    }

    /**
     * 更新用户信息
     */
    @PutMapping
    public R<String> update(@RequestBody User user) {
        user.setUpdateTime(LocalDateTime.now());
        userService.updateById(user);
        return R.success("更新成功");
    }

    /**
     * 更新用户状态（禁用/启用）
     */
    @PutMapping("/status")
    public R<String> updateStatus(@RequestBody User user) {
        log.info("更新用户状态：id = {}, status = {}", user.getId(), user.getStatus());
        
        if (user.getId() == null || user.getStatus() == null) {
            return R.error("参数错误");
        }
        
        // 只更新状态字段
        User updateUser = new User();
        updateUser.setId(user.getId());
        updateUser.setStatus(user.getStatus());
        updateUser.setUpdateTime(LocalDateTime.now());
        
        userService.updateById(updateUser);
        return R.success("更新状态成功");
    }

    /**
     * 分页查询用户列表
     */
    @GetMapping("/page")
    public R<Page<User>> page(
            @RequestParam(defaultValue = "1") int page,
            @RequestParam(defaultValue = "10") int pageSize, 
            @RequestParam(required = false) String keyword,
            @RequestParam(required = false) Integer role,
            @RequestParam(required = false) Integer status) {
        log.info("分页查询用户列表：page = {}, pageSize = {}, keyword = {}, role = {}, status = {}", 
                page, pageSize, keyword, role, status);
        
        // 创建分页对象
        Page<User> pageInfo = new Page<>(page, pageSize);
        
        // 构建查询条件
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        
        // 添加关键字搜索（用户名、昵称、邮箱、手机号）
        if (StringUtils.hasText(keyword)) {
            queryWrapper.like(User::getUsername, keyword)
                    .or().like(User::getNickname, keyword)
                    .or().like(User::getEmail, keyword)
                    .or().like(User::getPhone, keyword);
        }
        
        // 根据角色筛选
        if (role != null) {
            queryWrapper.eq(User::getRole, role);
        }
        
        // 根据状态筛选
        if (status != null) {
            queryWrapper.eq(User::getStatus, status);
        }
        
        // 按创建时间降序排序
        queryWrapper.orderByDesc(User::getCreateTime);
        
        // 执行查询
        userService.page(pageInfo, queryWrapper);
        log.info("查询结果：total = {}, records size = {}", pageInfo.getTotal(), pageInfo.getRecords().size());
        
        // 隐藏密码
        for (User user : pageInfo.getRecords()) {
            user.setPassword(null);
        }
        
        return R.success(pageInfo);
    }

    /**
     * 删除用户
     */
    @DeleteMapping("/{id}")
    public R<String> delete(@PathVariable Long id) {
        log.info("删除用户：id = {}", id);
        
        if (id == null) {
            return R.error("参数错误");
        }
        
        // 检查是否存在依赖数据，如评论、作品等
        // 实际项目中可能需要检查用户是否有关联数据，如评论、作品等
        // 如果有关联数据，可能需要先删除关联数据，或者采用逻辑删除
        
        userService.removeById(id);
        return R.success("删除成功");
    }
} 